{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "intro",
   "metadata": {},
   "source": [
    "# Introducción a los tipos primitivos y operaciones en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "concepto",
   "metadata": {},
   "source": [
    "## Paso 1: ¿Qué son los tipos primitivos?\n",
    "Los tipos primitivos son los elementos básicos con los que podemos trabajar en Python. Son los tipos de datos más simples que ofrece el lenguaje. Analicemos cada uno de ellos:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tipos-lista",
   "metadata": {},
   "source": [
    "- **Enteros (`int`)**: Números enteros sin decimales. Pueden ser positivos, negativos o cero.\n",
    "- **Números de coma flotante (`float`)**: Números con coma decimal.\n",
    "- **Cadenas (`str`)**: Valores de texto entre comillas simples (`'`) o dobles (`\"`).\n",
    "- **Booleanos (`bool`)**: Valores lógicos, verdaderos o falsos."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "enteros",
   "metadata": {},
   "source": [
    "## Paso 2: Enteros (`int`)\n",
    "Los enteros son números que no tienen parte decimal. Son el tipo numérico más básico.\n",
    "### Ejemplos:\n",
    "- `5` es un entero.\n",
    "- `-3` es un entero negativo.\n",
    "- `0` también es un entero, que no representa nada.\n",
    "Los enteros se utilizan cuando se necesitan representar números enteros, como contar objetos, medir distancias o cualquier cosa que no requiera decimales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "codigo-enteros",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer operations\n",
    "num1 = 10\n",
    "num2 = 3\n",
    "\n",
    "# Addition\n",
    "result_addition = num1 + num2  # Adding two integers\n",
    "print('Addition:', result_addition)  # Output: 13\n",
    "\n",
    "# Subtraction\n",
    "result_subtraction = num1 - num2  # Subtracting num2 from num1\n",
    "print('Subtraction:', result_subtraction)  # Output: 7\n",
    "\n",
    "# Multiplication\n",
    "result_multiplication = num1 * num2  # Multiplying two integers\n",
    "print('Multiplication:', result_multiplication)  # Output: 30\n",
    "\n",
    "# Division\n",
    "result_division = num1 / num2  # Dividing num1 by num2\n",
    "print('Division:', result_division)  # Output: 3.3333"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "flotantes",
   "metadata": {},
   "source": [
    "## Paso 3: Números de punto flotante (`float`)\n",
    "Los números de punto flotante representan números que contienen un punto decimal. Se utilizan para representar números reales que requieren una precisión mayor que la de los números enteros.\n",
    "### Ejemplos:\n",
    "- `3.14` es un número de punto flotante que representa Pi.\n",
    "- `-2.5` es un número de punto flotante negativo.\n",
    "- `0.0` también es un número de punto flotante que representa cero con precisión decimal.\n",
    "Los números de punto flotante son útiles al trabajar con mediciones, distancias, temperaturas o cálculos financieros que requieren decimales.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "codigo-flotantes",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Float operations\n",
    "num3 = 3.14\n",
    "num4 = 2.5\n",
    "\n",
    "# Addition\n",
    "result_addition_float = num3 + num4  # Adding two float numbers\n",
    "print('Addition (float):', result_addition_float)  # Output: 5.64\n",
    "\n",
    "# Subtraction\n",
    "result_subtraction_float = num3 - num4  # Subtracting num4 from num3\n",
    "print('Subtraction (float):', result_subtraction_float)  # Output: 0.64\n",
    "\n",
    "# Multiplication\n",
    "result_multiplication_float = num3 * num4  # Multiplying two float numbers\n",
    "print('Multiplication (float):', result_multiplication_float)  # Output: 7.85\n",
    "\n",
    "# Division\n",
    "result_division_float = num3 / num4  # Dividing num3 by num4\n",
    "print('Division (float):', result_division_float)  # Output: 1.256"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cadenas",
   "metadata": {},
   "source": [
    "## Paso 4: Cadenas (`str`)\n",
    "Las cadenas representan datos de texto. Cualquier carácter entre comillas, ya sean simples o dobles, se considera una cadena.\n",
    "### Ejemplos:\n",
    "- `'Hola'` es una cadena.\n",
    "- `'Python'` es una cadena.\n",
    "- `\"¡Hola!\"` también es una cadena, pero se usa entre comillas dobles.\n",
    "Las cadenas son útiles cuando se necesita representar texto, como nombres, direcciones, mensajes, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "codigo-cadenas",
   "metadata": {},
   "outputs": [],
   "source": [
    "# String operations\n",
    "str1 = 'Hello'\n",
    "str2 = 'World'\n",
    "\n",
    "# Concatenation\n",
    "result_concatenation = str1 + ' ' + str2  # Combine strings\n",
    "print('Concatenation:', result_concatenation)  # Output: 'Hello World'\n",
    "\n",
    "# Repetition\n",
    "result_repetition = str1 * 3  # Repeat the string 3 times\n",
    "print('Repetition:', result_repetition)  # Output: 'HelloHelloHello'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "booleanos",
   "metadata": {},
   "source": [
    "## Paso 5: Booleanos (`bool`)\n",
    "Los booleanos representan valores lógicos. Solo pueden tener uno de dos valores: `Verdadero` o `Falso`.\n",
    "### Ejemplos:\n",
    "- `Verdadero` representa un valor de verdad.\n",
    "- `Falso` representa un valor falso.\n",
    "Los booleanos se utilizan en operaciones lógicas y comparaciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "codigo-booleanos",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boolean operations\n",
    "bool1 = True\n",
    "bool2 = False\n",
    "\n",
    "# Logical AND\n",
    "result_and = bool1 and bool2  # True AND False\n",
    "print('AND operation:', result_and)  # Output: False\n",
    "\n",
    "# Logical OR\n",
    "result_or = bool1 or bool2  # True OR False\n",
    "print('OR operation:', result_or)  # Output: True\n",
    "\n",
    "# Logical NOT\n",
    "result_not = not bool1  # NOT True\n",
    "print('NOT operation:', result_not)  # Output: False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "operaciones",
   "metadata": {},
   "source": [
    "## Paso 6: Operaciones en Python\n",
    "Ahora, veamos cómo podemos realizar operaciones con estos tipos primitivos.\n",
    "### Operaciones con enteros (`int`)\n",
    "Puedes sumar, restar, multiplicar y dividir enteros como en matemáticas básicas.\n",
    "### Operaciones con flotantes (`float`)\n",
    "Los flotantes se pueden usar con los mismos operadores que los enteros. Sin embargo, al dividir dos enteros, Python devolverá un flotante (incluso si el resultado es un número entero).\n",
    "### Operaciones con cadenas (`str`)\n",
    "Las cadenas se pueden concatenar (combinar) usando el operador `+` o repetirse usando el operador `*`.\n",
    "### Operaciones con booleanos (`bool`)\n",
    "Puedes combinar valores booleanos usando operadores lógicos como `and`, `or` y `not`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ejercicios-operaciones",
   "metadata": {},
   "source": [
    "## Paso 7: Ejercicios prácticos sobre operaciones\n",
    "¡Ahora te toca a ti! Aquí tienes algunos ejercicios para practicar lo aprendido sobre operaciones con tipos primitivos.\n",
    "Intenta resolverlos por tu cuenta."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ejercicio1",
   "metadata": {},
   "source": [
    "### Ejercicio 1: Suma simple\n",
    "Escribe un programa que solicite al usuario dos números y los sume.\n",
    "Consejo: Puedes convertir la entrada del usuario en enteros o flotantes usando las funciones `int()` o `float()`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ejercicio2",
   "metadata": {},
   "source": [
    "### Ejercicio 2: Concatenación de cadenas\n",
    "Escribe un programa que solicite al usuario su nombre y apellido, y luego imprima un mensaje con su nombre completo.\n",
    "Consejo: Usa la concatenación de cadenas (`+`) para unir los dos nombres."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ejercicio3",
   "metadata": {},
   "source": [
    "### Ejercicio 3: Edad dentro de 5 años\n",
    "Escribe un programa que pregunte al usuario su edad y le indique cuántos años tendrá dentro de 5 años.\n",
    "Consejo: Convierte la edad a un entero antes de realizar el cálculo.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}